COMMENT ⊗   VALID 00006 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	header files & the like
C00004 00003	! Standard records 
C00015 00004	! data types
C00017 00005	! operators for expressions
C00020 00006	! predeclared variables & internal system variables
C00024 ENDMK
C⊗;
COMMENT header files & the like;

IFCR ¬DECLARATION(π) THENC 
	ENTRY;
	BEGIN "HALREC"

	REQUIRE "ABBREV.SAI[S,RHT]" SOURCE_FILE;
	REQUIRE "MACROS.SAI[S,RHT]" SOURCE_FILE;
	REQUIRE "RECAUX.HDR[S,RHT]" SOURCE_FILE;
	REQUIRE "LEPAUX.HDR[S,RHT]" SOURCE_FILE;
	REQUIRE "PRCAUX.HDR[S,RHT]" SOURCE_FILE;
	REQUIRE "REFBTS.DEF[S,RHT]" SOURCE_FILE;

	DEFINE HALRECTERNAL=⊂INTERNAL⊃;
	DEFINE HALRECEND=⊂END⊃;
	DEFINE HALRECSW = 1;
	DEFINE NOARITH = "TRUE";
	REQUIRE "ARITH.HDR[HAL,RHT]" SOURCE_FILE;
	
ELSEC
	REQUIRE "⊂⊃⊂⊃" DELIMITERS;
	REQUIRE "HALREC.REL[HAL,RHT]" LOAD_MODULE;
	DEFINE HALRECEND=⊂  ⊃;
	DEFINE HALRECTERNAL=⊂EXTERNAL⊃;
	DEFINE HALRECSW = 0;
ENDC


! a few constants;

DEFINE INCHES = "2.54";

HALRECTERNAL OWN INTEGER ARRAY PATCH[0:50];
! Standard records ;

DEFINE HALRTYPE(FOO,BAR) "<>" =
	< ASSIGNC BAR = CVPS(FOO)&"TYPE";
	  REDEFINE NHRECS=NHRECS+1;
	  DEFINE BAR = NHRECS>;
DEFINE HALRCLASS(FOO) "<>" = 
	< HALRTYPE(FOO);
	  HALRECTERNAL RECORD_CLASS FOO >;

DEFINE NHRECS=0;
	
IFCR ¬DECLARATION(_FACT_) THENC
	EXTERNAL RECORD_CLASS FACT(integer fake);
	ENDC

	DEFINE RCELL = ⊂RPTR(CELL)⊃;
	DEFINE REXPR = ⊂RANY⊃;
	DEFINE RVAR = ⊂RPTR(VARIABLE)⊃;
	DEFINE RSTMNT = ⊂RPTR(STMNT)⊃;
	DEFINE RSSS = ⊂RANY⊃;


	! Constants.  **** Now, record classes defined by ARITH ****;

	HALRTYPE(V3ECT);
	HALRTYPE(ROTN);
	HALRTYPE(TRANS);
	HALRTYPE(SVAL);
	HALRTYPE(TINFO);
	HALRTYPE(FRAME);

	! a special sort of locus expression;

	HALRCLASS (BPARAM) (REAL MXV,MNV,NV;INTEGER ROLE;RANY SEMANTICS);

	! expressions;

	HALRCLASS (EXPRN) (INTEGER DATATYPE,OP;RCELL ARGS);

	! Variables & their attributes;
				
	HALRCLASS (FLUENT) (RPTR(FACT) FACTID;RANY FREC,RETRPATT);
	HALRCLASS (SET_FLUENT) (RANY RETRPATT);
	HALRCLASS (CALCULATOR)(RPTR(FLUENT) PLNVAL;
			       RPTR(SET_FLUENT) DEPS;
			       SET NEEDED;REXPR FORM;INTEGER OFFSET;
			       RANY ITEMVAR NAME);

	HALRCLASS (VNODE) (INTEGER INVMARK;RPTR(VALU$) NOMVAL);
	HALRCLASS (VARIABLE) (RANY ITEMVAR NAME;INTEGER DATATYPE, OFFSET;
					RANY SEMANTICS;
					RPTR(FLUENT) PLNVAL;
					RPTR(SET_FLUENT) CALCS,DEPS,CHANGERS;
		!  Temp for RF:;	RANY VAL;
					INTEGER ATTRIBUTES;
					RANY BLK);
		! Variable attribute bits follow:   ;
		BITDEF(GLBAL,'1);  ! This variable is declared "global";
		! BLK is block in which this variable appears;

	! Control structures;

	HALRCLASS (STMNT)(RANY ITEMVAR ID;ITEMVAR IW,OW,PRC;RSSS SEMANTICS;
			INTEGER STLAB);


	HALRCLASS (PROG) (RPTR(STMNT) CODE);
	HALRCLASS (BLOCK) (RCELL CODE,VARS,CMONS,EVTS,CLCS,ALSOS;
				      RANY ITEMVAR BLID;
				      RANY PARENT);
			! As used by GOBBLE, BLID⊗ident≡var;
			! CLCS is a list of CALCULATORs. -- NOT VARIABLEs
			  ALSOS is a list of ALSODOs. -- NOT VARIABLEs
			  I am assuming (for now) that all CALCs or CHANGERs
			  are "set up" whenever their block is entered.
			  This is not strictly necessary & the work may
			  just as well be done when needed.

			  It is assumed that ALSOS & CALCS will all be
			  undone when the block is exited. In the case of
			  ALSOS, this means unlinking each changer from
			  whatever graph nodes it is linked to & freeing
			  up the storage.  In the case of CALCS, just
			  drop the pointer & allow variable killing to
			  do all the work.  I am assuming that a changer
			  will be put onto the corrrect block to govern its
			  "life". 
			;
	HALRCLASS (BLKOP) (INTEGER OP);
			! for the moment, this construct is used
			  just by WLDMOD:  The first statement in a block
			  (with declarations, etc) is BLKOP(1)
			  & the last statement is BLKOP(2).  Perhaps
			  Ray would like to use this, too;
			DEFINE ENTERBLOCK = 1;
			DEFINE LEAVEBLOCK = 2;

	HALRCLASS (CHANGER) (INTEGER OFFSET;RPTR(BLOCK) BLID;
			     RPTR(SET_FLUENT) TRIGGERS;
			     RPTR(STMNT) CODE;RANY ITEMVAR NAME);
			! Triggers is set of variables whose change triggers 
			  this fellow;

	HALRCLASS (COBLOCK) (RCELL CODE);
	HALRCLASS (TASKBLOCK) (RCELL CODE);
	HALRCLASS (FORR) (RVAR CONVAR; REXPR INITIAL, STEP, FINAL; RSTMNT BODY);
	HALRCLASS (WHIL) (REXPR COND; RSTMNT BODY);
	HALRCLASS (IFF) (REXPR COND; RSTMNT THN, ELS);

	! graph structure manipulators;

	HALRCLASS (ASSIGNMENT) (RVAR VAR; REXPR VAL);
	HALRCLASS (AFFIX) (RVAR FRAME1,FRAME2,BYVAR;REXPR ATEXP;RVAR RIGID;
						RCELL GPHCODE);
	HALRCLASS (UNFIX) (RVAR FRAME1,FRAME2;RCELL GPHCODE);
			! in both these cases, GPHCODE is list of graph
			  assignments & alsodo's.  Note: NOT of
			  STMNTS.
			;

	HALRCLASS (GASSIGN)(RPTR(VARIABLE) VAR;INTEGER OP;RPTR(CALCULATOR) CLC);
	    !  The OP has these meanings:
		1:	=	is computed by, "<="
		2:	≠	is not computed by, "<≠"
		3:	< or ←  is only computed by, "<<="
	    ;

	HALRCLASS (ALSODO)(RPTR(VARIABLE) VAR;INTEGER OP;RPTR(CHANGER) CHG);
	    ! ***** CHG used to be a stmnt ****;
	    !  The OP has these meanings:
		1:	When changing VAR also do CODE
		2:	When changing VAR dont do CODE
		3:	When changing VAR only do CODE
	    ;

	HALRCLASS (SPECVAL)(BOOLEAN OLD; INTEGER TYPE);
	    ! Either OLD or NEW, can be of any type;

	HALRCLASS (EVDO)(RVAR VAR; INTEGER OP);
	    !  OP = 0 for signal, =1 for wait;

	! quasi-statements;

	HALRCLASS (PVL)(RCELL VL;ITEMVAR WLD);
	HALRCLASS (DBD)(ITEMVAR WLD);
	HALRCLASS (NW)(ITEMVAR WLD);

	! misc statements;

	HALRCLASS (MOVE$) (RVAR WHAT;REXPR DEST;RCELL CLAUSES;
				     RVAR CF,DFTEMP;REXPR DEXP);
		! CF is the controllable frame for this motion statement.
		  DFTEMP is the temporary variable used to hold the
		         destination frame expression.
		  DEXP is the ACTUAL expression that must be evaluated
		       to compute a destination for the controllable frame CF.
		  **** At present, the program graph is NOT modified
			to generate an assignment statement into DFTEMP.
			It is assumed that the code generator will 
			generate code to evaluate the expression &
			then poke the value away.  WLDMOD will, however,
			call CHANGE to give DFTEMP a correct planning value.
		;

	HALRCLASS (CMON) (RPTR(EXPRN,VARIABLE) CONDITION; RSTMNT CONCLUSION;
		INTEGER OFFSET);
	HALRCLASS (CMABLE) (INTEGER OFFSET, FLAG);
		! (FLAG = TRUE) => enable, else disable;
	HALRCLASS (VIA) (REXPR PLACE,VELOC,TIME;INTEGER TIME_RELN;
		RSTMNT CODE);
	HALRCLASS (DEPROACH) (RVAR FRAME; BOOLEAN DEPARTURE);
	HALRCLASS (DURATION) (REXPR TIME; INTEGER TIME_RELN);
		! Note:  the time relations are the following:
		0	no relation given
		1	> (that is, a lower bound)
		2	< (that is, an upper bound)
		3	= (that is, an exact bound)
		;
	HALRCLASS (FORCE) (REXPR FIRECT, MDIRECT; INTEGER OFFSET);

	! Assertions & compile-time conditionals;

	HALRCLASS (NOMV)(REXPR E;ITEMVAR WLD);
	HALRCLASS (BINDV)(RPTR(VARIABLE) VAR;RANY RESULT);

	HALRCLASS (SFACT)(RCELL PATT;RPTR(FACT) FACT);
	HALRCLASS (AFACT)(INTEGER RELN;REXPR LEFT,RIGHT);
	HALRCLASS (ASSERT)(ITEMVAR WLD;RPTR(SFACT,AFACT) FACT);
	HALRCLASS (DENY)(ITEMVAR WLD;RPTR(SFACT,AFACT) FACT);

	HALRCLASS (CIF) (REXPR COND; RCELL THN, ELS);

	! Totally miscellaneous things;
	HALRCLASS (IDENT)(RANY ITEMVAR ID); ! used by GOBBLE;
	HALRCLASS (COMMNT) (RANY HESAYS);

	HALRECTERNAL RCLASS AFXDATA(RVAR A,B,T,YOUNGEST;
				    REXPR INVT;
				    RPTR(CALCULATOR) C1,C2;
				    RPTR(CHANGER) CHG);

! data types;

DEFINE  DEFDTYPE(MNE,XXX) "<>" = <
	REDEFINE NDTYPES=NDTYPES+1;
	ASSIGNC XXX = CVPS(MNE)&"_DTYPE";
	DEFINE XXX = NDTYPES>;

DEFINE NDTYPES=-1;
DEFDTYPE(INVALID);	! 0 is invalid;
DEFDTYPE(SVAL);		! scalar;
DEFDTYPE(V3ECT);	! 3 vector;
DEFDTYPE(ROTN);		! rotation;
DEFDTYPE(TRANS);	! transform matrix;
DEFDTYPE(FRAME);	! frame;

DEFDTYPE(ATOM);		! an "atom" -- symbolic only;
DEFDTYPE(STATEMENT);	! a "statement" variable;
DEFDTYPE(CLAUSE);	! a "clause" variable;
DEFDTYPE(EXPRESSION);	! an "expression" variable;

DEFDTYPE(EVENT);	! an "event" variable;
DEFDTYPE(WORLD);	! a "world" variable;

! note: Labels get loaded up with the semantics of the thing 
	pointed to.
;

DEFDTYPE(STMLAB);	! statement label;
DEFDTYPE(CLCLAB);	! calculator label;
DEFDTYPE(CHGLAB);	! changer label;
DEFDTYPE(OMNLAB);	! on-monitor label;
! operators for expressions;


IFCR HALRECSW THENC
DEFINE  DEFOP(MNE,XXX,YYY) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	ASSIGNC YYY = """"&CVPS(MNE)&"""";
	YYY,
	DEFINE XXX = NOPS>;
PRELOAD_WITH 
ELSEC
DEFINE  DEFOP(MNE,XXX) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	DEFINE XXX = NOPS>;
ENDC

DEFINE OPBRK(MXID,MNID,XXX) "<>" = <
	ASSIGNC XXX = "MAX_"&CVPS(MXID)&"_OP";
	DEFINE XXX = NOPS;
	ASSIGNC XXX = "MIN_"&CVPS(MNID)&"_OP";
	DEFINE XXX = NOPS+1>;

!  This list updated 6/30/75 by RF;
DEFINE NOPS=-1;				! Return nothing;
DEFOP(INVALID);
DEFOP(NO);		! no-op;
OPBRK(NO,SVAL);				! Return scalars;
DEFOP(SADD);		! s+s;
DEFOP(SSUB);		! s-s;
DEFOP(SNEG);		! -s;
DEFOP(SMUL);		! s*s;
DEFOP(SDIV);		! s/s;
DEFOP(SLT);		! S<S;
DEFOP(SEQ);		! S=S;
DEFOP(SLE);		! S≤S;
DEFOP(SGE);		! S≥S;
DEFOP(SNE);		! S≠S;
DEFOP(SGT);		! S>S;
DEFOP(VMAGN);		! |v|;
DEFOP(VDOT);		! v.v;
OPBRK(SVAL,V3ECT);			! Return vectors;
DEFOP(VMAKE);		! vector(s,s,s);
DEFOP(SVMUL);		! s*v;
DEFOP(VADD);		! v+v;
DEFOP(RVMUL);		! r*v;
DEFOP(TVMUL);		! t*v;
OPBRK(V3ECT,ROTN);			! Return rotns;
DEFOP(AXW_ROTN);
OPBRK(ROTN,TRANS);			! Return transes;
DEFOP(TMAKE);		! trans(r,v);
DEFOP(FTOF);		! f → f;	!  *** kill this soon ***;
DEFOP(TVADD);		! t+v;
DEFOP(TTMUL);		! t*t;
DEFOP(TINVRT);		! inverse(t);
OPBRK(TRANS,FRAME);			! Return frames;
DEFOP(FMAKE);		! frame(R,v);
DEFOP(TFMAKE);		! frame(T);
OPBRK(FRAME,LAST);
DEFOP(LAST);				! Never return;
IFCR HALRECSW THENC
"INVALID";INTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ELSEC
EXTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ENDC

! predeclared variables & internal system variables;

IFCR HALRECSW THENC
	DEFINE HALITM(ID,SID,NARG,INID) "<>" = 
		<IFCR LENGTH(CVPS(SID)) THENC 
			DEFINE ID = CVPS(SID);
			ENDC
		INTERNAL ITEMVAR ID;
		ASSIGNC INID = "INI_"&CVPS(ID);
		SIMPLE PROCEDURE INID;
			BEGIN
			ID←CVSI(CVPS(ID),HALIFG);
			IF HALIFG THEN
				NEW_PNAME(ID←NEW NARG,CVPS(ID));
			END;
		REQUIRE INID INITIALIZATION>;
	INTEGER HALIFG;
		
ELSEC
	DEFINE HALITM(ID,SID,NARG,INID) "<>" = 
		<IFCR LENGTH(CVPS(SID)) THENC 
			DEFINE ID = CVPS(SID);
			ENDC
		EXTERNAL ITEMVAR ID>;
ENDC



IFCR ¬DECLARATION(PDVSW) THENC DEFINE PDVSW = ⊂FALSE⊃; ENDC

IFCR PDVSW THENC
    DEFINE PDV(ID,HDT,OFFST,INID) "<>" =
	< 
	  INTERNAL RPTR(VARIABLE) ID;
	  IFCR ¬LENGTH(CVPS(INID)) THENC ASSIGNC INID="INI_"&CVPS(ID); ENDC
	  PROCEDURE INID;
		BEGIN
		RANY ITEMVAR IV;
		EXTERNAL RPTR(VARIABLE) PROCEDURE NEW_VAR(ITEMVAR IV;INTEGER DT;
								RPTR(BLOCK) BID);
		IV←NEW(NULL_RECORD);
		NEW_PNAME(IV,"ID");
		ID←∂(IV)←NEW_VAR(IV,HDT,NULL_RECORD);
		VARIABLE:OFFSET[ID] ← OFFST;
		END;
	  REQUIRE INID INITIALIZATION>;
ELSEC

    DEFINE PDV(ID,HDT,OFFST) "<>" =
	< EXTERNAL RPTR(VARIABLE) ID >;

ENDC

PDV(YARM,FRAME_DTYPE,'10);
PDV(YHAND,SVAL_DTYPE,'12);
PDV(BARM,FRAME_DTYPE,'14);
PDV(BHAND,SVAL_DTYPE,'16);
PDV(NEWV,FRAME_DTYPE,'0);  ! Added by RF.  Never use the offset;
PDV(OLDV,FRAME_DTYPE,'0);  ! Added by RF.  Never use the offset;

! some standard pattern things;

DEFINE AFFIXED "<>" = <ATCHD>;

PDV(AFFIXED,ATOM_DTYPE,0);
PDV(WAS_AFFIXED,ATOM_DTYPE,0);
PDV(RIGIDLY,ATOM_DTYPE,0);
PDV(NONRIGIDLY,ATOM_DTYPE,0);


! Patterns:

    [ AFFIXED,f1,f2,byvar,rgf ]
	rgf = RIGIDLY or NONRIGIDLY

;

REQUIRE UNSTACK_DELIMITERS;
HALRECEND